home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / GameKit / Headers / gamekit / DirtPile.h < prev    next >
Text File  |  1995-06-12  |  3KB  |  73 lines
  1.  
  2. // This object tracks the dirty rectangle of the frame buffer.
  3. // If two rects overlap, they are coalesced.  If they don't
  4. // overlap, they are kept separate.  This way, when a redraw
  5. // is done, we have two flushes that are small rather than one
  6. // large flush.  (The large flush would draw *lots* of unnecessary
  7. // pixels!)
  8.  
  9. // Many thanks to Sam Streeper for giving me the idea to create this object.
  10. // It was originally based upon code snippets which he gave me, taken from
  11. // the game BoinkOut.  Thanks, Sam!
  12.  
  13. // Since Sam's suggestions, I have tried to speed up this object while
  14. // adding code to allow tuning of the algorithm to various situations.
  15. // You have two parameters:  how often should rects be coalesced and
  16. // when to coalesce.
  17. // The first param works like this...  the algorithm to do the
  18. // coalesce is O(n^3).  Thus, we want to keep n as small as possible.
  19. // hence, how often should we do a coalesce?  if often enough, we keep
  20. // n reasonable (hopefully) and if too often, we waste time checking
  21. // for possible coalescing that doesn't exist...
  22. // The next param is based on when to coalesce.  Basically, the idea
  23. // of tracking dirty rects is to keep from flushing clean parts of the
  24. // buffer.  Now, if two rects overlap by only a pixel, and then we do
  25. // a coalesce, then we re-draw a lot of clean area:  (clean is "C")
  26. // +----+
  27. // |    |  C
  28. // +----+----+
  29. //   C  |    |
  30. //      +----+
  31. // In such a case, we probably shouldn't coalesce.  On the other hand,
  32. // if the overlapping rects overlap by a lot, we want to coalesce so that
  33. // we don't redraw much of the dirty parts of the buffer twice.  So, you
  34. // set the do it/don't do it threshold by setting the percent of dirty area
  35. // versus coalesced area.  If there isn't at least that much dirty area in
  36. // relation to the coalesced area, then the coalesce won't happen.  Note
  37. // that 50% and below will always coalesce!
  38.  
  39. #import <appkit/appkit.h>
  40.  
  41. #define MAX_RECTS    1024    // should be more than enough, and it's easier than
  42.     // making it dynamic.  (Not that I couldn't.... :-)  )
  43.  
  44. extern BOOL coalesce(NXRect *p1, NXRect *p2, double percent);
  45.  
  46. @interface DirtPile:Object
  47. {
  48.     int maxRects;        // max number of rects in list
  49.     int numRects;        // number of rects in list
  50.     NXRect rectList[MAX_RECTS];    // list of dirty rects
  51.     BOOL allDirty;        // set if you want next flush to be everything
  52.     NXColor noBufferColor;
  53.     double percentOverlap;        // how much overlap (%) before we coalesce?
  54.     int coalesceFrequency;    // coalesce after every X rects added
  55.     int rectsAdded;
  56.     BOOL manyFlushes;
  57. }
  58.  
  59. - init;                            // initialize the instance
  60. - addRegion:(float)x :(float)y :(float)w :(float)h;    // add a dirty rect
  61. - addRegion:(const NXRect *)rect;                    // add a dirty rect
  62. - fullRedraw:sender :buffer;    // assumed to be a view
  63. - doRedraw:buffer;    // flush dirty rects from buffer to screen
  64. - setAllDirty;        // makes next flush be whole buffer
  65. - sendDirtTo:aDirtPile;        // add all our dirty rects to aDirtPile
  66. - setNoBufferColor:(NXColor)aColor; // set color to draw if no buffer
  67. - (double)percentDirtyForCoalesce;
  68. - setPercentDirtyForCoalesce:(double)val;
  69. - (BOOL)manyFlushes;
  70. - setManyFlushes:(BOOL)flag;
  71.  
  72. @end
  73.